Managed fixes for async task tracking #123727

rcj1 · 2026-01-28T19:24:11Z

This PR includes a few additions to the runtime-async handling loop to facilitate inspection by a debugger - specifically, Visual Studio.

Timestamp tracking for continuations. In VS there is a feature that lets you see, while F5 debugging, the relative start times and durations of different tasks. There is only one actual Task at the root of an await chain, but we intend to replicate the outward behavior in runtime-async by treating Continuations as "virtual Tasks". As such, we populate a dictionary to track the start times for each logical invocation.
TPL events. In Concord in asyncv1 we are notified of Task status changes via TPL events; specifically, we use these events to detect which Tasks are currently active and which thread each Task runs on. There are ways to do this without TPL in Concord; however, I believe a change to this would be across different (non-runtime async) Tasks and beyond the scope of this PR.

dotnet-policy-service · 2026-01-28T21:01:15Z

Tagging subscribers to this area: @steveisok, @tommcdon, @dotnet/dotnet-diag
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR adds managed fixes for async task tracking by introducing tick count tracking for runtime async tasks and continuations to support debugging scenarios.

Changes:

Adds two new ConcurrentDictionary fields to track task and continuation tick counts for debugging
Implements methods to set, get, update, and remove tick count tracking for both tasks and continuations
Integrates tick count tracking into the continuation allocation and dispatch flow
Adds TPL event source tracing for synchronous work begin/end and operation begin/end events

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 6 comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs	Adds static dictionaries and helper methods for tracking task and continuation tick counts, removes unnecessary blank line
src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs	Integrates tick count tracking into continuation lifecycle, adds ContinuationEqualityComparer, extends AsyncDispatcherInfo with Task field, adds TPL event source tracing

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

Copilot · 2026-01-29T18:47:41Z

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

+        {
+            if (s_asyncDebuggingEnabled)
+            {
+                s_runtimeAsyncContinuationTicks ??= new Collections.Concurrent.ConcurrentDictionary<Continuation, long>(ContinuationEqualityComparer.Instance);


Inconsistent namespace qualification: The ConcurrentDictionary type should be fully qualified as System.Collections.Concurrent.ConcurrentDictionary to match the field declarations on lines 184 and 187. The file does not have a using System.Collections.Concurrent; directive.

Copilot · 2026-01-29T18:47:41Z

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

+        {
+            if (s_asyncDebuggingEnabled)
+            {
+                s_runtimeAsyncContinuationTicks ??= new Collections.Concurrent.ConcurrentDictionary<Continuation, long>(ContinuationEqualityComparer.Instance);


Inconsistent namespace qualification: The ConcurrentDictionary type should be fully qualified as System.Collections.Concurrent.ConcurrentDictionary to match the field declarations on lines 184 and 187. The file does not have a using System.Collections.Concurrent; directive.

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

noahfalk · 2026-01-30T07:15:18Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

        }
    }

+    internal class ContinuationEqualityComparer : IEqualityComparer<Continuation>


What difference does it make specifying this comparer? Is this a workaround for missing functionality in the Continuation class where most objects have this default behavior but Continuations are special?

Yes, the virtual functions do not work on Continuations.

It can use a comment

noahfalk · 2026-01-30T07:16:07Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

+#else
+        [FieldOffset(8)]
+#endif
+        public Task Task;


A comment describing which Task gets stored here and when would be helpful.

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

noahfalk · 2026-01-30T07:32:56Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs


                        ref byte resultLoc = ref nextContinuation != null ? ref nextContinuation.GetResultStorageOrNull() : ref GetResultStorage();
+                        long tickCount = Task.GetRuntimeAsyncContinuationTicks(curContinuation, out long tickCountVal) ? tickCountVal : Environment.TickCount64;
+                        Task.UpdateRuntimeAsyncTaskTicks(this, tickCount);


I would have guessed the tick count represented the first time a Task starts doing work but this seems to be updating the tick count every time a new continuation starts. Is that the desired behavior? It would be helpful to have a nice comment somewhere that describes what behavior we are trying to achieve with these side data structures.

I have added some comments on the methods and around them

noahfalk · 2026-01-30T07:36:27Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

+                        Task.UpdateRuntimeAsyncTaskTicks(this, tickCount);
                        Continuation? newContinuation = curContinuation.ResumeInfo->Resume(curContinuation, ref resultLoc);

+                        Task.RemoveRuntimeAsyncContinuationTicks(curContinuation);


If the continuation executes quickly is there a risk its already deleted before the debugger ever gets an opportunity to observe it? Would that matter or the debugger only cares about observing the tasks which are in-progress at the moment a debug event occurs?

I should add comments to all of this code. The UpdateRuntimeAsyncTaskTicks Is just to keep track of the start time of the invocation currently inflight, as it is not on the chain. Once its work is done we remove it.

noahfalk · 2026-01-30T07:47:47Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

            Continuation newContinuation = (Continuation)RuntimeTypeHandle.InternalAllocNoChecks(contMT);
 #endif
            prevContinuation.Next = newContinuation;
+            Task.SetRuntimeAsyncContinuationTicks(newContinuation, Environment.TickCount64);


we also mentioned swapping from TickCount to StopWatch if the debugger cares about getting higher precision timings.

This is good because the etw events are also QPC timed

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated 5 comments.

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

Added comments to clarify the purpose of the Task field.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated 5 comments.

Copilot · 2026-02-02T19:01:48Z

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

+        // Needed because Continuations that are inflight have already been dequeued from the chain.
+        internal static System.Collections.Concurrent.ConcurrentDictionary<int, long>? s_runtimeAsyncTaskTicks;
+        // Dictionary to store debug info about runtime-async Continuations.
+        // The TickCount field stores the QPC tick count when the logical invocation to which the Continuation belongs started.
+        // The ID field stores a unique ID for the Continuation, similar to Task IDs.


The comment on line 181 says 'Dictionary that relates a runtime-async Task's ID to the QPC tick count' but doesn't explain the purpose or lifecycle of this mapping. Consider adding documentation explaining when entries are added/removed and how this differs from s_runtimeAsyncContinuationTicks.

Suggested change

// Needed because Continuations that are inflight have already been dequeued from the chain.

internal static System.Collections.Concurrent.ConcurrentDictionary<int, long>? s_runtimeAsyncTaskTicks;

// Dictionary to store debug info about runtime-async Continuations.

// The TickCount field stores the QPC tick count when the logical invocation to which the Continuation belongs started.

// The ID field stores a unique ID for the Continuation, similar to Task IDs.

// Entries are added when a runtime-async Task begins executing a logical invocation and removed when that invocation

// completes (i.e. when the Task is no longer considered inflight). This mapping is used only for debugging/

// diagnostics (e.g. Async Causality and debugger support) to recover timing information for currently executing

// runtime-async Tasks whose continuations have already been dequeued from the async method's continuation chain.

internal static System.Collections.Concurrent.ConcurrentDictionary<int, long>? s_runtimeAsyncTaskTicks;

// Dictionary to store debug info about runtime-async Continuations.

// The key is the Continuation instance, and the value is RuntimeAsyncContinuationDebugInfo:

// - The TickCount field stores the QPC tick count when the logical invocation to which the Continuation belongs

// started (which may be earlier than the point at which the continuation itself begins executing).

// - The ID field stores a unique ID for the Continuation, similar to Task IDs, to aid debugger correlation.

// Entries are added when a runtime-async Continuation is created/scheduled and removed when that continuation has

// finished executing or is otherwise no longer relevant. Unlike s_runtimeAsyncTaskTicks, which is keyed by Task ID

// and tracks inflight Task invocations, this dictionary is keyed by Continuation and tracks per-continuation debug

// information across the logical async invocation.

Copilot · 2026-02-02T19:01:48Z

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

+            s_runtimeAsyncContinuationTicks ??= new Collections.Concurrent.ConcurrentDictionary<Continuation, RuntimeAsyncContinuationDebugInfo>(ContinuationEqualityComparer.Instance);
+            s_runtimeAsyncContinuationTicks.TryAdd(continuation, new RuntimeAsyncContinuationDebugInfo(tickCount));


The dictionary initialization pattern is duplicated across multiple methods (lines 225, 241, 254). Consider extracting this into a helper method or property to reduce duplication.

Copilot · 2026-02-02T19:01:49Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

+                        RuntimeAsyncContinuationDebugInfo? debugInfo = null;
+                        if (Task.s_asyncDebuggingEnabled)
+                        {
+                            debugInfo = Task.GetRuntimeAsyncContinuationDebugInfo(curContinuation, out RuntimeAsyncContinuationDebugInfo? debugInfoVal) ? debugInfoVal : new RuntimeAsyncContinuationDebugInfo(Stopwatch.GetTimestamp());


This line is complex with nested ternary operations and method calls. Consider splitting into multiple lines for better readability, such as checking GetRuntimeAsyncContinuationDebugInfo first and then creating a new instance if needed.

Suggested change

debugInfo = Task.GetRuntimeAsyncContinuationDebugInfo(curContinuation, out RuntimeAsyncContinuationDebugInfo? debugInfoVal) ? debugInfoVal : new RuntimeAsyncContinuationDebugInfo(Stopwatch.GetTimestamp());

RuntimeAsyncContinuationDebugInfo? debugInfoVal;

if (Task.GetRuntimeAsyncContinuationDebugInfo(curContinuation, out debugInfoVal))

{

debugInfo = debugInfoVal;

}

else

{

debugInfo = new RuntimeAsyncContinuationDebugInfo(Stopwatch.GetTimestamp());

}

Copilot · 2026-02-02T19:01:49Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

+
                        if (newContinuation != null)
                        {
+                            // we have a new Continuation that belongs to the same logical invocation as the previous; propagate debug info from previous continuation


The comment should clarify that 'invocation' refers to the logical async operation. Consider rewording to 'propagate debug info from the previous continuation to maintain the same logical invocation context'.

Suggested change

// we have a new Continuation that belongs to the same logical invocation as the previous; propagate debug info from previous continuation

// we have a new Continuation that belongs to the same logical async operation as the previous; propagate debug info from the previous continuation to maintain the same logical invocation context

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

jkotas · 2026-02-03T04:08:41Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

+                    while (nc != null)
+                    {
+                        // On suspension we set tick info for all continuations that have not yet had it set.
+                        Task.SetRuntimeAsyncContinuationTickCount(nc, Stopwatch.GetTimestamp());


Suggested change

Task.SetRuntimeAsyncContinuationTickCount(nc, Stopwatch.GetTimestamp());

Task.SetRuntimeAsyncContinuationTimestamp(nc, Stopwatch.GetTimestamp());

In .NET, TickCount typically means time stamp measured in milliseconds. I would avoid using that name for time stamps measured in some other units. Just call it Timestamp?

jkotas · 2026-02-03T04:09:23Z

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

+                {
+                    while (nc != null)
+                    {
+                        // On suspension we set tick info for all continuations that have not yet had it set.


Suggested change

// On suspension we set tick info for all continuations that have not yet had it set.

// On suspension we set timestamp for all continuations that have not yet had it set.

e

7d950cb

github-actions bot added the needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners label Jan 28, 2026

dotnet-policy-service bot assigned rcj1 Jan 28, 2026

jkotas added runtime-async area-Diagnostics-coreclr and removed needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners labels Jan 28, 2026

This was referenced Jan 29, 2026

The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#3008

Open

[android-arm64] The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#6408

Open

TBD: remove unneeded updates

788fb65

Copilot AI review requested due to automatic review settings January 29, 2026 18:37

Copilot started reviewing on behalf of rcj1 January 29, 2026 18:38 View session

Copilot AI reviewed Jan 29, 2026

View reviewed changes

This was referenced Jan 30, 2026

"We stopped hearing from agent Azure Pipelines 32. Verify the agent machine is running and has a healthy network connection" dotnet/dnceng#1886

Open

iOS.Device test WorkItemExecutions #122874

Open

noahfalk reviewed Jan 30, 2026

View reviewed changes

adding IDs etc

908059e

build-analysis bot mentioned this pull request Jan 30, 2026

[android][arm64] System.Net.Sockets.Tests.SendTo_SyncForceNonBlocking.Datagram_UDP_ShouldImplicitlyBindLocalEndpoint fails with NetworkUnreachable #120526

Open

comments and restructure etc

6bc980b

Copilot AI review requested due to automatic review settings January 31, 2026 20:57

Copilot started reviewing on behalf of rcj1 January 31, 2026 20:58 View session

Copilot AI reviewed Jan 31, 2026

View reviewed changes

Enhance comments for Task field in AsyncHelpers

79ced18

Added comments to clarify the purpose of the Task field.

rcj1 force-pushed the managed-fixes branch from df57a44 to 79ced18 Compare January 31, 2026 23:50

This was referenced Feb 1, 2026

XHarness package install failure on iOS due to devicectl NSPOSIXErrorDomain error 49 #123796

Open

System.Transactions.Tests.OleTxTests.Recovery timeout #122621

Open

rcj1 marked this pull request as ready for review February 2, 2026 18:50

Copilot AI review requested due to automatic review settings February 2, 2026 18:51

Copilot started reviewing on behalf of rcj1 February 2, 2026 18:51 View session

Copilot AI reviewed Feb 2, 2026

View reviewed changes

rcj1 requested a review from tommcdon February 2, 2026 21:40

build-analysis bot mentioned this pull request Feb 2, 2026

slow macOS - "##[error]The job running on agent Azure Pipelines 9 ran longer than the maximum time of 60 minutes." dotnet/dnceng#1883

Open

3 tasks

revert continuation IDs

2ba51a4

jkotas reviewed Feb 3, 2026

View reviewed changes

-        // Needed because Continuations that are inflight have already been dequeued from the chain.
-        internal static System.Collections.Concurrent.ConcurrentDictionary<int, long>? s_runtimeAsyncTaskTicks;
-        // Dictionary to store debug info about runtime-async Continuations.
-        // The TickCount field stores the QPC tick count when the logical invocation to which the Continuation belongs started.
-        // The ID field stores a unique ID for the Continuation, similar to Task IDs.
+        // Entries are added when a runtime-async Task begins executing a logical invocation and removed when that invocation
+        // completes (i.e. when the Task is no longer considered inflight). This mapping is used only for debugging/
+        // diagnostics (e.g. Async Causality and debugger support) to recover timing information for currently executing
+        // runtime-async Tasks whose continuations have already been dequeued from the async method's continuation chain.
+        internal static System.Collections.Concurrent.ConcurrentDictionary<int, long>? s_runtimeAsyncTaskTicks;
+        // Dictionary to store debug info about runtime-async Continuations.
+        // The key is the Continuation instance, and the value is RuntimeAsyncContinuationDebugInfo:
+        //   - The TickCount field stores the QPC tick count when the logical invocation to which the Continuation belongs
+        //     started (which may be earlier than the point at which the continuation itself begins executing).
+        //   - The ID field stores a unique ID for the Continuation, similar to Task IDs, to aid debugger correlation.
+        // Entries are added when a runtime-async Continuation is created/scheduled and removed when that continuation has
+        // finished executing or is otherwise no longer relevant. Unlike s_runtimeAsyncTaskTicks, which is keyed by Task ID
+        // and tracks inflight Task invocations, this dictionary is keyed by Continuation and tracks per-continuation debug
+        // information across the logical async invocation.

		s_runtimeAsyncContinuationTicks ??= new Collections.Concurrent.ConcurrentDictionary<Continuation, RuntimeAsyncContinuationDebugInfo>(ContinuationEqualityComparer.Instance);
		s_runtimeAsyncContinuationTicks.TryAdd(continuation, new RuntimeAsyncContinuationDebugInfo(tickCount));

-                            debugInfo = Task.GetRuntimeAsyncContinuationDebugInfo(curContinuation, out RuntimeAsyncContinuationDebugInfo? debugInfoVal) ? debugInfoVal : new RuntimeAsyncContinuationDebugInfo(Stopwatch.GetTimestamp());
+                            RuntimeAsyncContinuationDebugInfo? debugInfoVal;
+                            if (Task.GetRuntimeAsyncContinuationDebugInfo(curContinuation, out debugInfoVal))
+                            {
+                                debugInfo = debugInfoVal;
+                            }
+                            else
+                            {
+                                debugInfo = new RuntimeAsyncContinuationDebugInfo(Stopwatch.GetTimestamp());
+                            }

	// we have a new Continuation that belongs to the same logical invocation as the previous; propagate debug info from previous continuation
	// we have a new Continuation that belongs to the same logical async operation as the previous; propagate debug info from the previous continuation to maintain the same logical invocation context

	Task.SetRuntimeAsyncContinuationTickCount(nc, Stopwatch.GetTimestamp());
	Task.SetRuntimeAsyncContinuationTimestamp(nc, Stopwatch.GetTimestamp());

	// On suspension we set tick info for all continuations that have not yet had it set.
	// On suspension we set timestamp for all continuations that have not yet had it set.

Managed fixes for async task tracking #123727

Are you sure you want to change the base?

Managed fixes for async task tracking #123727

Conversation

rcj1 commented Jan 28, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

dotnet-policy-service bot commented Jan 28, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 29, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Feb 2, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 2, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 2, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 2, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

rcj1 commented Jan 28, 2026 •

edited

Loading